#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
#include <ctime>
#include <algorithm>
#include <math.h>

using namespace std;

//服务器结构
struct Server{
	string type;
	int cpuA, cpuB, memA, memB, serverCost, powerCost;
	float ratio;//内核比
	float unitPrice;//单价
	//空参构造器
	Server(){}
	//带参构造器
	Server(string type, int cpuCore, int memSize, int sCost, int pCost):type(type),serverCost(sCost),powerCost(pCost){
		this->cpuA = cpuCore / 2;
		this->cpuB = this->cpuA;
		this->memA = memSize / 2;
		this->memB = this->memA;
		this->ratio = (float)memSize/cpuCore;
		this->unitPrice =  2 * (float)sCost/(cpuCore+memSize);//如果只是用来排序比大小的话，乘不乘 2 差别不大
	}
};

//虚拟机结构
struct VirtualMachine{
	string type;
	int cpuCore, memSize, isDual;
	float ratio;//内核比
	//空参构造器
	VirtualMachine(){}
	//带参构造器
	VirtualMachine(string type, int cpuCore, int memSize, int isDual):type(type),cpuCore(cpuCore),memSize(memSize),isDual(isDual){
		this->ratio = (float)memSize/cpuCore;
	}
};

//添加请求结构
struct Request{
	string type;//add or del
	string vmType, vmId;
	int vmCpu, vmMem, isDual;
	Request(){}//空参构造器
	Request(string type, string vmType, string vmId, int vmCpu, int vmMem, int isDual):type(type),vmType(vmType),vmId(vmId),vmCpu(vmCpu),vmMem(vmMem),isDual(isDual){}
	//当其为一条删除请求时，只有其vmId有效，其他的数据别访问，会出错。
	Request(string type, string vmId):type(type),vmId(vmId){}
};

//对服务器，按 内核比 升序排序
bool sv_cmp_ratio_up (Server const &s1, Server const s2){
	return (s1.ratio < s2.ratio) || (s1.ratio==s2.ratio && s1.serverCost<s2.serverCost);
}


/******* 全局变量 ***********************/
unordered_map<string, Server> svInfos;              //原始的服务器信息
unordered_map<string, VirtualMachine> vmInfos;      //原始的虚拟机信息
unordered_map<string, string> vmToSv;               //每种类型的虚拟机该对应到哪台服务器上(key=虚拟机类型，value=服务器类型)
vector<Request> dayReqs;                         //每日的请求
vector<Server> svResources;                         //已购服务器，每次购买都往尾部添加，其所在容器中的位置索引就是其编号
unordered_map<string, vector<int>> svMapBuy;        //每种类型的已购服务器(key=服务器类型，value=服务器编号数组)
unordered_map<string, vector<Request>> svMapReqs;//每天对于各类服务器的请求
#define DeployInfo vector<int>                      //虚拟机的部署信息。{服务器编号, 总占用cpu, 总占用mem, maybe 部署节点}。长度为3->双节点部署;当长度为4->单节点部署（0-A,1->B）
unordered_map<string, DeployInfo> vmOnServer;       //记录虚拟机运行在哪台服务器上(key=虚拟机id(不是类型), value={服务器编号,占用cpu,占用mem,部署节点})
vector<vector<string>> svRunVms;                    //记录已购的每台服务器上的各自运行的虚拟机Id。长度和已购服务器的数量对应
vector<int> svRunVmsNumber;                         //记录已购的每台服务器上的各自运行的虚拟机数量（看似显得多余，其实是为了方便后续的处理）。长度和已购服务器的数量对应
vector<vector<string>> purchase_info;//每天的购买信息
vector<vector<string>> migrate_info;//每天的迁移信息
vector<vector<string>> deploy_info;//每天的部署信息
//提交时可能用不到的变量
# define INPUT_REDIRECTION_1 "training-data/training-1.txt"  //输入重定向
# define INPUT_REDIRECTION_2 "training-data/training-2.txt"  //输入重定向
# define OUTPUT_REDIRECTION "result.txt"                     //输出重定向
long long SERVERCOST=0, POWERCOST=0, TOTALCOST=0;            //各种成本
long long SC=0, PC=0, TC=0;                                  //两份数据的成本
/*****************************************/


/****************** 读数据构建各种类型的 服务器 和 虚拟机 ********************/
void readServer(string &serverType, string &cpuCore, string &memSize, string &serverCost, string &powerCost){
	string _serverType = "";
    for(int i =1; i<serverType.size()-1; i++) _serverType += serverType[i];
    int _cpuCore=0, _memSize=0, _serverCost=0, _powerCost=0;
    for(int i=0; i<cpuCore.size()-1; i++) _cpuCore = 10*_cpuCore + cpuCore[i] - '0';
    for(int i=0; i<memSize.size()-1; i++) _memSize = 10*_memSize + memSize[i] - '0';
    for(int i=0; i<serverCost.size()-1; i++) _serverCost = 10*_serverCost + serverCost[i] - '0';
    for(int i=0; i<powerCost.size()-1; i++) _powerCost = 10*_powerCost + powerCost[i] - '0';
	svInfos[_serverType] = Server{_serverType, _cpuCore, _memSize, _serverCost, _powerCost};
}
void readVm(string &vmType, string &cpuCore, string &memSize, string &isDual){
    string _vmType = "";
    for(int i=1; i<vmType.size()-1; i++) _vmType += vmType[i];
    int _cpuCore=0, _memSize=0, _isDual=0;
    for(int i=0; i<cpuCore.size()-1; i++) _cpuCore = _cpuCore*10 + cpuCore[i] - '0';
    for(int i=0; i<memSize.size()-1; i++) _memSize = _memSize*10 + memSize[i] - '0';
    if(isDual[0] == '1') _isDual = 1;
    vmInfos[_vmType] = VirtualMachine{_vmType, _cpuCore, _memSize, _isDual};
}
void readServerAndVmInfos(){
	int svNum;//服务器数量
	string type, cpuCore, memSize, serverCost, powerCost, isDual;
	scanf("%d", &svNum);
	for (int i=0; i<svNum; i++){
		cin>>type>>cpuCore>>memSize>>serverCost>>powerCost;
		readServer(type, cpuCore, memSize, serverCost, powerCost);
	}
	int vmNum;//虚拟机数量
    scanf("%d",&vmNum);
	for (int i =0; i<vmNum; i++){
        cin>>type>>cpuCore>>memSize>>isDual;
        readVm(type, cpuCore, memSize, isDual);
    }
}
/*****************************************************************************/

/************ 解决如何寻找每台虚拟机的最佳服务器 *************/
int binarySearch_left_bound(vector<Server> const &servers, float target_ratio){
	if(servers.size() == 0) return -1;
	int left=0, right=servers.size();
	while (left < right){
		int mid = (left + right) / 2;
		if (target_ratio == servers[mid].ratio){
			right = mid;//注意这里是个非常神奇的地方
		}else if (target_ratio > servers[mid].ratio){
			left = mid + 1;
		}else if (target_ratio < servers[mid].ratio){
			right = mid;
		}
	}
	if (left == servers.size()) left--;
	return left;
}
string getMostSuitableServer(VirtualMachine const &vm, vector<Server> const &servers){
	float ratio = vm.ratio;
	int index = binarySearch_left_bound(servers, ratio);
	Server sv = servers[index];//理想的比较匹配的服务器，但是可能放不下当前服务器
	int needCpuCore = vm.isDual==0 ? vm.cpuCore : vm.cpuCore/2;
	int needMemSize = vm.isDual==0 ? vm.memSize : vm.memSize/2;
	if(sv.cpuA>=needCpuCore && sv.memA>=needMemSize) return sv.type;//如果能放下就直接返回
	int l_idx=index-1, r_idx=index+1;
	while(l_idx > -1){//直接向左搜索，可能有Bug，不过目前没有遇到
		sv = servers[l_idx++];
		if (sv.cpuA>=needCpuCore && sv.memA>=needMemSize) return sv.type;
	}
	return "";//其实这个 "" 永远也得不到返回
}
void createVmMapToSV(){
	vector<Server> servers;
	for (auto const pair:svInfos){
		Server sv = pair.second;
		servers.emplace_back(sv);
	}
	sort(servers.begin(), servers.end(), sv_cmp_ratio_up);//排序
	for (auto const pair:vmInfos){
		string vmType = pair.first;
		VirtualMachine vm = pair.second;
		vmToSv[vmType] = getMostSuitableServer(vm, servers);
	}
}
/*************************************************************/

/************** 读数据构建每日请求 ****************/
void readAddRequest(string &op, string & reqVmType, string &reqVmId){
	string _op, _reqVmType, _reqVmId;
    _op = op.substr(1, op.size()-2);
    _reqVmType = reqVmType.substr(0, reqVmType.size()-1);
    _reqVmId = reqVmId.substr(0, reqVmId.size() -1);
    VirtualMachine vm = vmInfos[_reqVmType];
    dayReqs.emplace_back(Request{_op, _reqVmType, _reqVmId, vm.cpuCore, vm.memSize, vm.isDual});
}
void readDelRequest(string &op, string &reqVmId){
	string _op, _reqVmId;
    _op = op.substr(1, op.size()-2);
    _reqVmId = reqVmId.substr(0, reqVmId.size()-1);
    dayReqs.emplace_back(Request{_op, _reqVmId});
}
void readDayRequests(int dayReqNumber){
	string op, reqVmType, reqVmId;
	dayReqs.clear();//清空前一日请求
	for (int i=0; i<dayReqNumber; i++){
		cin>>op;
		if(op[1] == 'a'){
			cin>>reqVmType>>reqVmId;
			readAddRequest(op, reqVmType, reqVmId);;
		}else{
			cin>>reqVmId;
			readDelRequest(op, reqVmId);
		}
	}
}
/**************************************************/

//将添加请求分流到每种类型的服务器上。分流后的每一波中的请求，依然保留着相对处理顺序。
void distributeRequests(int day){
	svMapReqs.clear();//每天清空，重新算
	for(int i=0; i<dayReqs.size(); i++){
		Request const &req = dayReqs[i];
		if(req.type=="add"){
			string svType = vmToSv[req.vmType];
			svMapReqs[svType].emplace_back(req);
		}else{//注意赛题已说明，可能存在当日添加当日删除的虚拟机。
			if(vmOnServer.find(req.vmId) == vmOnServer.end()){//当日即将删除的虚拟机在vmOnServer中无记录。
				for(int j=0; j<i; j++){//则在当日的请求中一定能找到该台虚拟机的添加信息。
					if(dayReqs[i].vmId == req.vmId) {
						svMapReqs[vmToSv[dayReqs[i].vmType]].emplace_back(req);
						break;
					}
				}
				continue;
			}
			int svId = vmOnServer[req.vmId][0];
			string svType=svResources[svId].type;//获取到所放服务器的型号
			svMapReqs[svType].emplace_back(req);
		}
	}
}

//模拟每一波添加请求。
int handleBranchRequests(string const &svType, vector<Request> const &reqs){
	int buy_number = 0;//记录本波请求可能购买的服务器数量
	vector<int> &svs = svMapBuy[svType];//这种类型的已购服务器
	string vmType, vmId;
	int needCpu, needMem, isDual;
	for (Request const &req : reqs){
		if(req.type == "add"){//这是一条添加虚拟机的请求
			vmType=req.vmType, vmId=req.vmId, isDual=req.isDual;
			needCpu = isDual==0 ? req.vmCpu : req.vmCpu/2;
			needMem = isDual==0 ? req.vmMem : req.vmMem/2;
			int index=0;//标记当前访问的服务器
			while (index < svs.size()){
				int svId = svs[index];//真实的服务器Id
				Server &sv = svResources[svId];//用&是因为可能会修改服务器可用资源量
				if(isDual){//需双节点部署
					if(sv.cpuA>=needCpu && sv.cpuB>=needCpu && sv.memA>=needMem && sv.memB>=needMem){
						sv.cpuA -= needCpu;
						sv.cpuB -= needCpu;
						sv.memA -= needMem;
						sv.memB -= needMem;
						vmOnServer[vmId]=DeployInfo{svId, needCpu, needMem};//记录该虚拟机的部署信息，长度为3
						svRunVmsNumber[svId]++;
						svRunVms[svId].emplace_back(vmId);
						break;
					}
				}else{//需单节点部署。可以先判断一下A节点还是B节点剩得多
					if(sv.cpuA >= sv.cpuB){//A节点剩得多
						if(sv.cpuA>=needCpu && sv.memA>=needMem){//并且A节点能放下
							sv.cpuA -= needCpu;
							sv.memA -= needMem;
							vmOnServer[vmId] = DeployInfo{svId, needCpu, needMem, 0};//记录该虚拟机的部署信息，长度为4。0表示部署到A节点
							svRunVmsNumber[svId]++;//当前服务器上运行的虚拟机个数 + 1;
							svRunVms[svId].emplace_back(vmId);
							break;
						}
						if(sv.cpuB>=needCpu && sv.memB>=needMem){//虽然A节点剩得多，但是A节点放不下，那么看B节点能不能放下
							sv.cpuB -= needCpu;
							sv.memB -= needMem;
							vmOnServer[vmId] = DeployInfo{svId, needCpu, needMem, 1};//记录该虚拟机的部署信息，长度为4。1表示部署到B节点
							svRunVmsNumber[svId]++;//当前服务器上运行的虚拟机个数 + 1;
							svRunVms[svId].emplace_back(vmId);
							break;
						}
					}else{//B节点剩得多
						if(sv.cpuB>=needCpu && sv.memB>=needMem){//并且B节点能放下
							sv.cpuB -= needCpu;
							sv.memB -= needMem;
							vmOnServer[vmId] = DeployInfo{svId, needCpu, needMem, 1};//记录该虚拟机的部署信息，长度为4。1表示部署到B节点
							svRunVmsNumber[svId]++;//当前服务器上运行的虚拟机个数 + 1;
							svRunVms[svId].emplace_back(vmId);
							break;
						}
						if(sv.cpuA>=needCpu && sv.memA>=needMem){//虽然B节点剩得多，但是B节点放不下，那么看A节点能不能放下
							sv.cpuA -= needCpu;
							sv.memA -= needMem;
							vmOnServer[vmId] = DeployInfo{svId, needCpu, needMem, 0};//记录该虚拟机的部署信息，长度为4。0表示部署到A节点
							svRunVmsNumber[svId]++;//当前服务器上运行的虚拟机个数 + 1;
							svRunVms[svId].emplace_back(vmId);
							break;
						}
					}
				}
				index++;
			}
			//说明该类已购服务器放不下了，买买买
			if(index == svs.size()){
				int svId = svResources.size();//新买的服务器，它的id应该是这个
				Server sv = svInfos[svType];
				if(isDual){//双节点部署
					sv.cpuA -= needCpu;
					sv.cpuB -= needCpu;
					sv.memA -= needMem;
					sv.memB -= needMem;
					vmOnServer[vmId] = DeployInfo{svId, needCpu, needMem};//记录该虚拟机的部署信息，长度为3
				}else{//单节点部署。
					//新买服务器时，第一个虚拟机默认放在B节点上
					sv.cpuB -= needCpu;
					sv.memB -= needMem;
					vmOnServer[vmId] = DeployInfo{svId, needCpu, needMem, 1};//记录该虚拟机的部署信息，长度为4。1表示部署到B节点
				}
				svResources.emplace_back(sv);//把该台服务器放到所有已购买服务器的尾部
				svRunVmsNumber.emplace_back(1);//当前服务器上的虚拟机个数为 1，因为这个新买的服务器目前只加了一个虚拟机上去
				svRunVms.emplace_back(vector<string>{vmId});
				svs.emplace_back(svId);//同步更新该编号数组。
				buy_number++;//本波请求中，需购买的服务器的数量 + 1
				SERVERCOST += sv.serverCost;//服务器购买成本
			}
		}else{//相反这是一条删除虚拟机的请求
			string vmId = req.vmId;//删除请求Request中，只有type属性和vmId属性合法
			DeployInfo vmDeInfo = vmOnServer[vmId];//通过虚拟机Id找到其部署信息
			int svId=vmDeInfo[0], occupiedCpu=vmDeInfo[1], occupiedMem=vmDeInfo[2];//获取部署关键信息
			Server &sv=svResources[svId];//这里使用 &, 因为要去修改服务器的资源量
			if(vmDeInfo.size() == 3){//该虚拟机之前是双节点部署的
				sv.cpuA += occupiedCpu;
				sv.cpuB += occupiedCpu;
				sv.memA += occupiedMem;
				sv.memB += occupiedMem;
			}else{//若长度为4表明该虚拟机之前是单节点部署的
				if(vmDeInfo[3] == 0){//之前是部署在A节点上
					sv.cpuA += occupiedCpu;
					sv.memA += occupiedMem;
				}else{
					sv.cpuB += occupiedCpu;
					sv.memB += occupiedMem;
				}
			}
			svRunVmsNumber[svId]--;//该服务器上运行的虚拟机数量 - 1
			vector<string> &vmIds=svRunVms[svId];
			vmIds.erase(remove(vmIds.begin(), vmIds.end(), vmId), vmIds.end());//没错删除就是这么复杂
			vmOnServer.erase(vmId);//删除该条部署信息
		}
	}
	//一波操作之后全局变量 svResources，svMapBuy[svType], svRunVms，vmOnServer 都被修改了
	return buy_number;//返回本波请求中，需购买服务器的数量
}

//快速排序，按照服务器上运行的虚拟机数量
void quickSort_runVms_up(vector<int> &svIds, int l, int r){
	vector<int> const &number = svRunVmsNumber;
	if(l < r){
		int i=l, j=r;
		int x=svIds[l];
		while(i < j){
			while(number[svIds[j]]>=number[x] && i<j) j--;
			if(i < j) svIds[i++] = svIds[j];
			while(number[svIds[i]]<=number[x] && i<j) i++;
			if(i < j) svIds[j--] = svIds[i];
		}
		svIds[i] = x;
		quickSort_runVms_up(svIds, l, i-1);
		quickSort_runVms_up(svIds, i+1, r);
	}
}

//快速排序，按照服务器剩余资源量
void quickSort_rest_down(vector<int> &svIds, int l, int r){
	
}

//先不管，反正一上来就迁移
void migrate(int day){
	vector<string> day_migrate_info{""};//用来存每日的迁移信息。先加入一个空字符串留给 migrate_num
	int max_migrate_num = floor((float)vmOnServer.size()/200);//当日最大可迁移数量，不超过 max_migrate_num
	int migrate_num = 0;//当日已迁移数量
	
	for(auto const &pair : svMapBuy){//还是分波考虑
		vector<int> svIds = pair.second;
		quickSort_runVms_up(svIds, 0, svIds.size()-1);
		for(int i=0; i<svIds.size()-1; i++){//从前往后遍历
			int svId = svIds[i];//服务器Id
			Server &sv = svResources[svId];//服务器
			vector<string> const vmIds = svRunVms[svId];//服务器上的虚拟机们
			for(string const &vmId : vmIds){//遍历每台虚拟机
				DeployInfo &deInfo = vmOnServer[vmId];//虚拟机部署信息
				int dual = deInfo.size()==3 ? 1 : 0;
				int occupiedCpu=deInfo[1], occupiedMem=deInfo[2];
				if (migrate_num == max_migrate_num) goto STOP_MIGRATE;//达到最大迁移次数
				for(int j=svIds.size()-1; j>i; j--){
					int goal_svId = svIds[j];//目标服务器Id
					Server &goal_sv = svResources[goal_svId];//目标服务器
					if(dual){//双节点部署
						if(goal_sv.cpuA>=occupiedCpu && goal_sv.cpuB>=occupiedCpu && goal_sv.memA>=occupiedMem && goal_sv.memB>=occupiedMem){
							sv.cpuA += occupiedCpu;//原服务器资源增加
							sv.cpuB += occupiedCpu;
							sv.memA += occupiedMem;
							sv.memB += occupiedMem;
							svRunVmsNumber[svId]--;
							vector<string> &VMIDS=svRunVms[svId];
							VMIDS.erase(remove(VMIDS.begin(), VMIDS.end(), vmId), VMIDS.end());//没错删除就是这么复杂
							goal_sv.cpuA -= occupiedCpu;//目标服务器资源减少
							goal_sv.cpuB -= occupiedCpu;
							goal_sv.memA -= occupiedMem;
							goal_sv.memB -= occupiedMem;
							svRunVmsNumber[goal_svId]++;
							svRunVms[goal_svId].emplace_back(vmId);
							//修改部署信息
							deInfo[0] = goal_svId;
							migrate_num++;//当日已迁移数量 + 1
							day_migrate_info.emplace_back("(" + vmId + ", " + to_string(goal_svId) + ")\n");
							break;
						}	
					}else{//单节点部署
						if(goal_sv.cpuA>=occupiedCpu && goal_sv.memA>=occupiedMem){//A节点能放下
							if(deInfo[3]==0){//原来部署在A节点还是B节点
								sv.cpuA += occupiedCpu;
								sv.memA += occupiedMem;
							}else{
								sv.cpuB += occupiedCpu;
								sv.memB += occupiedMem;
							}
							svRunVmsNumber[svId]--;
							vector<string> &VMIDS=svRunVms[svId];
							VMIDS.erase(remove(VMIDS.begin(), VMIDS.end(), vmId), VMIDS.end());//没错删除就是这么复杂
							goal_sv.cpuA -= occupiedCpu;
							goal_sv.memA -= occupiedMem;
							svRunVmsNumber[goal_svId]++;
							svRunVms[goal_svId].emplace_back(vmId);
							//修改部署信息
							deInfo[0] = goal_svId;
							deInfo[3] = 0;
							migrate_num++;//当日已迁移数量 + 1
							day_migrate_info.emplace_back("(" + vmId + ", " + to_string(goal_svId) + ", A)\n");
							break;
						}
						if(goal_sv.cpuB>=occupiedCpu && goal_sv.memB>=occupiedMem){//B节点能放下
							if(deInfo[3]==0){//原来部署在A节点还是B节点
								sv.cpuA += occupiedCpu;
								sv.memA += occupiedMem;
							}else{
								sv.cpuB += occupiedCpu;
								sv.memB += occupiedMem;
							}
							svRunVmsNumber[svId]--;
							vector<string> &VMIDS=svRunVms[svId];
							VMIDS.erase(remove(VMIDS.begin(), VMIDS.end(), vmId), VMIDS.end());//没错删除就是这么复杂
							goal_sv.cpuB -= occupiedCpu;
							goal_sv.memB -= occupiedMem;
							svRunVmsNumber[goal_svId]++;
							svRunVms[goal_svId].emplace_back(vmId);
							//修改部署信息
							deInfo[0] = goal_svId;
							deInfo[3] = 1;
							migrate_num++;//当日已迁移数量 + 1
							day_migrate_info.emplace_back("(" + vmId + ", " + to_string(goal_svId) + ", B)\n");
							break;
						}
					}
				}
			}
		}
	}
STOP_MIGRATE:
//	if(day==0 || day%50==0){
//		cout<<day<<" --> "<<max_migrate_num<<" --> "<<migrate_num<<endl;
//	}
	day_migrate_info[0] = "(migration, " + to_string(migrate_num) + ")\n";//将migrate_num转化成字符串放到数组的首位
	migrate_info.emplace_back(day_migrate_info);//存一下每日的迁移信息
}

//处理每日请求
void handleOneDayRequests(int day){
	int purchTypeNumber=0, purch_num=0;
	vector<string> day_purchase_info{""}; //记录每个类型购买了多少，字符串格式为 “（类型，数量）”, 先加入一个空字符串留给 purchTypeNumber
	distributeRequests(day);//将添加请求分流到每种类型的服务器上。
	migrate(day);//迁移
	//遍历每类服务器上的请求
	for(auto &pair : svMapReqs){
		string svType = pair.first;
		vector<Request> &reqs = pair.second;
		purch_num = handleBranchRequests(svType, reqs);
		//如果本次的服务器类型购买数量不是0，则购买种类数量+1
		if(purch_num != 0){
			purchTypeNumber++;
			day_purchase_info.emplace_back("(" + svType + ", " + to_string(purch_num) +")\n");
		}
	}
	
	//构建每日的部署信息，为输出做准备
	vector<string> day_deploy_info;
	for(auto &req : dayReqs){
		if(req.type == "add"){
			DeployInfo depInfo = vmOnServer[req.vmId];
			if(depInfo.size()==3){//双部署
				day_deploy_info.emplace_back("(" + to_string(depInfo[0]) + ")\n");
			}else{//单部署
				string nodeInfo = depInfo[3]==0 ? "A" : "B";
				day_deploy_info.emplace_back("(" + to_string(depInfo[0]) + ", " + nodeInfo + ")\n");
			}
			
		}else{//删除
			//删除没有输出
		}
	}
	//保存输出信息
	day_purchase_info[0] = "(purchase, " + to_string(purchTypeNumber) + ")\n";//将purchTypeNumber转化成字符串放到数组的首位
	purchase_info.emplace_back(day_purchase_info);//存一下每日的购买请求
	deploy_info.emplace_back(day_deploy_info);//存一下每日的部署请求
}

//打印输出结果
void print(){
	for(int i=0; i<purchase_info.size(); i++){//遍历每天
		for(string &info:purchase_info[i]){//每天购买
			cout<<info;
		}
		for(string &info:migrate_info[i]){//每天迁移
			cout<<info;
		}
		for(string &info:deploy_info[i]){//每天部署
			cout<<info;
		}
	}
}

//计算每日的耗电成本
void computePowerCost(){
	for(int i=0; i<svRunVms.size(); i++){
        if(svRunVms[i].size() != 0){
            POWERCOST += svResources[i].powerCost;
        }
    }
}

void cloudResourceSchedulingAlgorithm(){
	readServerAndVmInfos();//读取服务器和虚拟机信息
	createVmMapToSV();//创建每台虚拟机到服务器的映射关系
	int reqDays=0, dayReqNumber=0;
	scanf("%d", &reqDays);
	for (int day=0; day<reqDays; day++){
		scanf("%d", &dayReqNumber);
		readDayRequests(dayReqNumber);
		handleOneDayRequests(day);
		//computePowerCost();
	}
	print();//打印输出结果
}

int main(){
//	freopen(OUTPUT_REDIRECTION, "w", stdout);
//	clock_t start, finish;

//	//第一份文件
//	start = clock();
//	freopen(INPUT_REDIRECTION_1, "r", stdin);
	cloudResourceSchedulingAlgorithm();
//	finish = clock();
//	TOTALCOST = SERVERCOST + POWERCOST;//总成本
//	SC += SERVERCOST, PC += POWERCOST, TC += TOTALCOST;
//	printf("\nCompute Time: %f s \n", double(finish-start)/CLOCKS_PER_SEC);
//	printf("Server Cost: %lld \nPower Cost: %lld \nTotal Cost: %lld \n", SERVERCOST, POWERCOST, TOTALCOST);
//	
//	
//	//变量清零
//	svInfos.clear();
//	vmInfos.clear();
//	vmToSv.clear();
//	dayReqs.clear();
//	svResources.clear();
//	svMapBuy.clear();
//	svMapReqs.clear();
//	vmOnServer.clear();
//	svRunVms.clear();
//	svRunVmsNumber.clear();
//	purchase_info.clear();
//	migrate_info.clear();
//	deploy_info.clear();
//	SERVERCOST=0;
//	POWERCOST=0;
//	TOTALCOST=0;
//	
//	//第二份文件
//	start = clock();
//	freopen(INPUT_REDIRECTION_2, "r", stdin);
//	cloudResourceSchedulingAlgorithm();
//	finish = clock();
//	TOTALCOST = SERVERCOST + POWERCOST;//总成本
//	SC += SERVERCOST, PC += POWERCOST, TC += TOTALCOST;
//	printf("\nCompute Time: %f s \n", double(finish-start)/CLOCKS_PER_SEC);
//	printf("Server Cost: %lld \nPower Cost: %lld \nTotal Cost: %lld \n", SERVERCOST, POWERCOST, TOTALCOST);
//	
//	//打印两份文件的总成本
//	printf("\nServer Cost: %lld \nPower Cost: %lld \nTotal Cost: %lld \n", SC, PC, TC);
	return 0;
}